home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / ASTRONOM / H139.ZIP / UI101.ZIP / IO / GR / GR_MGR.C < prev    next >
C/C++ Source or Header  |  1991-11-04  |  24KB  |  1,024 lines
  1. /****************************************************************
  2.  
  3.        gr_mgr.c       Implementation of Graphics Interface 
  4.                       for Bellcore MGR (tm)
  5.  
  6.             Copyright (c) 1991, Ted A. Campbell
  7.  
  8.             Bywater Software
  9.             P. O. Box 4023 
  10.             Duke Station 
  11.             Durham, NC  27706
  12.  
  13.             email: tcamp@hercules.acpub.duke.edu
  14.  
  15.     Copyright and Permissions Information:
  16.  
  17.     All U.S. and international copyrights are claimed by the
  18.     author. The author grants permission to use this code
  19.     and software based on it under the following conditions:
  20.     (a) in general, the code and software based upon it may be 
  21.     used by individuals and by non-profit organizations; (b) it
  22.     may also be utilized by governmental agencies in any country,
  23.     with the exception of military agencies; (c) the code and/or
  24.     software based upon it may not be sold for a profit without
  25.     an explicit and specific permission from the author, except
  26.     that a minimal fee may be charged for media on which it is
  27.     copied, and for copying and handling; (d) the code must be 
  28.     distributed in the form in which it has been released by the
  29.     author; and (e) the code and software based upon it may not 
  30.     be used for illegal activities. 
  31.  
  32. ****************************************************************/
  33.  
  34. #include "stdio.h"
  35. #include "bw.h"
  36. #include "gr.h"
  37. #include "mgrterm.h"      /* for Bellcore MGR (tm) */
  38.  
  39. #ifdef __STDC__
  40. #include "malloc.h"
  41. #else
  42. extern char * malloc();
  43. #endif
  44.  
  45. #define X_OFFSET   12
  46. #define Y_OFFSET   12
  47. #define MAX_X      640
  48. #define MAX_Y      450
  49.  
  50. #define    CHECK_PARAMS    TRUE
  51.  
  52. #define MGR_BLSIZE  32
  53.  
  54. #define MGR_FONT0    10
  55. #define MGR_FONT1    11
  56. #define MGR_FONT2    12
  57. #define MGR_FONT3    13
  58. #define MGR_FONT4    14
  59.  
  60. #define    MGR_DRAWMAIN    0        /* mgr primary screen */
  61. #define MGR_DRAWHIDE    1        /* mgr secondary (hidden) screen */
  62. #define MGR_DRAWGRID    2        /* mgr grid screen */
  63. #define MGR_DRAWSTART   6        /* start assignable screens */
  64.  
  65. #define    TINYFONT            /* try to use tiny font */
  66.  
  67. int   gr_screens = 2;
  68. int   gr_colors = 2;
  69. int   gr_pxsize = 287;
  70. int   gr_pysize = 428;
  71. int   gr_ismouse = TRUE;
  72. int   gr_clipping = FALSE;
  73. int   gr_blitting = TRUE;
  74. int   gr_saving = TRUE;
  75.  
  76. static int   mgr_wno;
  77.  
  78. static int   mgr_cltarget;
  79. static int   mgr_border;
  80. static int   mgr_hidden = FALSE;
  81. static int   mgr_curwind = MGR_DRAWMAIN;
  82. static int   mgr_xblocks, mgr_yblocks;
  83. static int   mgr_clx1, mgr_cly1, mgr_clx2, mgr_cly2;
  84. struct gr_window *mgr_grwind;
  85.  
  86. extern tam_imsize();
  87.  
  88. /****************************************************************
  89.  
  90.    gr_init()
  91.  
  92. ****************************************************************/
  93.  
  94. gr_init( grwindow, font_path )
  95.    struct gr_window *grwindow;
  96.    char *font_path;
  97.    {
  98.    register int x, y, i;
  99.    int target_x, target_y;
  100.    static xmax, ymax;
  101.    static char _host[ 32 ];
  102.  
  103.    mgr_grwind = grwindow;
  104.  
  105.    /* set up MGR system */
  106.  
  107.    m_setup( M_FLUSH );
  108.    m_ttyset();
  109.  
  110.    /* get maximum sizes from MGR system */
  111.  
  112.    get_param( _host, &xmax, &ymax, &mgr_border );
  113.  
  114.    /* calculate target size for window, x axis */
  115.  
  116.    if ( ( xmax - ( X_OFFSET * 2) ) < MAX_X )
  117.       {
  118.       target_x = xmax - ( X_OFFSET * 2 );
  119.       }
  120.    else
  121.       {
  122.       target_x = MAX_X;
  123.       }
  124.  
  125.    /* calculate target size for window, y axis */
  126.  
  127.    if ( ( ymax - ( Y_OFFSET * 2) ) < MAX_Y )
  128.       {
  129.       target_y = ymax - ( Y_OFFSET * 2 );
  130.       }
  131.    else
  132.       {
  133.       target_y = MAX_Y;
  134.       }
  135.  
  136.    /* get new window for this application */
  137.  
  138.    mgr_wno = m_makewindow( X_OFFSET, Y_OFFSET, target_x, target_y );
  139.    m_selectwin( mgr_wno );
  140.    mgr_grwind->xmax = target_x - ( ( mgr_border * 2 ) + 1 );
  141.    mgr_grwind->ymax = target_y - ( ( mgr_border * 2 ) + 1 );
  142.  
  143.    /* load fonts */
  144.  
  145.  
  146.    x = m_loadfont( MGR_FONT4, "gal12x20r.fnt" );
  147. #ifdef    OLD_DEBUG
  148.       fprintf( stderr, "load font %d returned %d \n", MGR_FONT4, x );
  149.       getchar();
  150. #endif
  151.    x = m_loadfont( MGR_FONT3, "cour8x16r.fnt" );
  152. #ifdef    OLD_DEBUG
  153.       fprintf( stderr, "load font %d returned %d \n", MGR_FONT3, x );
  154.       getchar();
  155. #endif
  156.    x = m_loadfont( MGR_FONT2, "cour7x14r.fnt" );
  157. #ifdef    OLD_DEBUG
  158.       fprintf( stderr, "load font %d returned %d \n", MGR_FONT2, x );
  159.       getchar();
  160. #endif
  161.    x = m_loadfont( MGR_FONT1, "cour6x12r.fnt" );
  162. #ifdef    OLD_DEBUG
  163.       fprintf( stderr, "load font %d returned %d \n", MGR_FONT1, x );
  164.       getchar();
  165. #endif
  166.    x = m_loadfont( MGR_FONT0, "tiny4x7r.fnt" );
  167. #ifdef    OLD_DEBUG
  168.       fprintf( stderr, "load font %d returned %d \n", MGR_FONT0, x );
  169.       getchar();
  170. #endif
  171.  
  172.  
  173.    gr_font( GR_PRIMARY, F_DEFAULT, 10 );
  174.  
  175.    /* set to absolute window coordinate mode */
  176.  
  177.    m_setmode( M_ABS );
  178. /*   m_setmode( M_NOWRAP ); */
  179.  
  180.    /* calculate number of blocks necessary for fill patterns */
  181.  
  182.    mgr_xblocks = ( ( target_x ) / MGR_BLSIZE ) + 1;
  183.    mgr_yblocks = ( ( target_y ) / MGR_BLSIZE ) + 1;
  184.  
  185. #ifdef OLD_DEBUG
  186.    fprintf( stderr, "x size = %d, x blocks = %d \n", mgr_grwind->xmax, mgr_xblocks );
  187.    fprintf( stderr, "y size = %d, y blocks = %d \n", mgr_grwind->ymax, mgr_yblocks );
  188.    kb_rx();
  189. #endif
  190.  
  191.    /* get scratchpad bitmaps */
  192.  
  193.    m_bitcreate( MGR_DRAWGRID, mgr_xblocks * MGR_BLSIZE, 
  194.       mgr_yblocks * MGR_BLSIZE );
  195.  
  196. #ifdef USEFILL
  197.    m_bitcreate( MGR_DRAWFILL, mgr_xblocks * MGR_BLSIZE, 
  198.       mgr_yblocks * MGR_BLSIZE );
  199. #endif
  200.  
  201.    m_bitcreate( MGR_DRAWHIDE, target_x, target_y );
  202.  
  203. #ifdef    OLD_DEBUG
  204.    fprintf( stderr, "Bitmaps created. \n" );
  205. #endif
  206.  
  207.    /* signon message */
  208.  
  209.    fprintf( stderr, "Implementation of Bywater Graphics (gr) Standard\n" );
  210.    fprintf( stderr, "for Bellcore MGR (tm). This implementation copyright\n" );
  211.    fprintf( stderr, "(c) 1990, Ted A. Campbell, Bywater Software \n" );
  212.    fprintf( stderr, "\nInitializing: " );
  213.  
  214. #ifdef USEFILL
  215.  
  216.    /* fill first block of fill bitmap with solid pattern */
  217.  
  218. #ifdef OLD_DEBUG
  219.    fprintf( stderr, "Initializing SOLID fill: " );
  220. #endif
  221.    m_func( B_SET );
  222.    for ( y = 0; y < MGR_BLSIZE; ++y )
  223.       {
  224.       fprintf( stderr, "." );
  225.       m_lineto( MGR_DRAWFILL, 0, y, MGR_BLSIZE, y );
  226.       }
  227.  
  228.    /* now replicate the block pattern throughout the fill bitmap */
  229.  
  230. #ifdef OLD_DEBUG
  231.    fprintf( stderr, "\nCopying FILL images: " );
  232. #endif
  233.    m_func( B_SRC );
  234.    for ( y = 0; y < mgr_yblocks; ++y )
  235.       {
  236. #ifdef OLD_DEBUG
  237.       fprintf( stderr, "\nFILL line %d: ", y );
  238. #endif
  239.       fprintf( stderr, "." );
  240.       for ( x = 0; x < mgr_xblocks; ++x )
  241.          {
  242.          if ( ( x == 0 ) && ( y == 0 ))
  243.             {
  244.             }
  245.          else
  246.             {
  247.             m_bitcopyto( x * MGR_BLSIZE, y * MGR_BLSIZE, 
  248.                MGR_BLSIZE, MGR_BLSIZE, 
  249.                0, 0, MGR_DRAWFILL, MGR_DRAWFILL );
  250.             }
  251.          }
  252.       }
  253.  
  254. #endif        /* USEFILL */
  255.  
  256.    /* fill grid bitmap with solid pattern */
  257.  
  258. #ifdef OLD_DEBUG
  259.    fprintf( stderr, "\nInitializing GRID fill: " );
  260. #endif
  261.    for ( y = 0; y < MGR_BLSIZE; y += 2 )
  262.       {
  263.  
  264. #ifdef OLD_DEBUG
  265.       fprintf( stderr, "\nLine %d: ", y );
  266. #endif
  267.       for ( x = 0; x < MGR_BLSIZE; x += 2 )
  268.          {
  269.          fprintf( stderr, "." );
  270.          m_func( B_SET );
  271.          m_lineto( MGR_DRAWGRID, x, y, x, y );
  272.          m_func( B_CLEAR );
  273.          m_lineto( MGR_DRAWGRID, x + 1, y, x + 1, y );
  274.          m_func( B_CLEAR );
  275.          m_lineto( MGR_DRAWGRID, x, y + 1, x, y + 1 );
  276.          m_func( B_SET );
  277.          m_lineto( MGR_DRAWGRID, x + 1, y + 1, x + 1, y + 1 );
  278.          }
  279.       }
  280.  
  281.    /* now replicate the block pattern throughout the fill bitmap */
  282.  
  283. #ifdef OLD_DEBUG
  284.    fprintf( stderr, "\nCopying GRID images: " );
  285. #endif
  286.    m_func( B_SRC );
  287.    for ( y = 0; y < mgr_yblocks; ++y )
  288.       {
  289. #ifdef OLD_DEBUG
  290.       fprintf( stderr, "\nGRID line %d: ", y );
  291. #else
  292.       fprintf( stderr, "." );
  293. #endif
  294.       for ( x = 0; x < mgr_xblocks; ++x )
  295.          {
  296.          if ( ( y == 0 ) && ( x == 0 ))
  297.             {
  298.             }
  299.          else
  300.             {
  301. #ifdef OLD_DEBUG
  302.             fprintf( stderr, "." );
  303. #endif
  304.             m_bitcopyto( x * MGR_BLSIZE, y * MGR_BLSIZE, 
  305.                MGR_BLSIZE, MGR_BLSIZE, 
  306.                0, 0, MGR_DRAWGRID, MGR_DRAWGRID );
  307.             }
  308.          }
  309.       }
  310.  
  311. #ifdef OLD_DEBUG
  312.    fprintf( stderr, "\nGRID bitmap filled. \n" );
  313. #endif
  314.  
  315.    /* turn cursor off */
  316.  
  317.    m_setcursor( CS_INVIS );
  318.  
  319.    /* move cursor to 0,0 to be safe */
  320.  
  321.    m_move( 0, 0 );
  322.  
  323.    /* note that system is initailized */
  324.  
  325.    mgr_grwind->initialized = TRUE;
  326.    return TRUE;
  327.    }
  328.  
  329. /****************************************************************
  330.  
  331.    gr_deinit()
  332.  
  333. ****************************************************************/
  334.  
  335. gr_deinit( )
  336.    {
  337.    m_bitdestroy( MGR_DRAWGRID );
  338.    m_bitdestroy( MGR_DRAWHIDE );
  339.    m_destroywin( mgr_wno );
  340.    m_ttyreset();
  341.    }
  342.  
  343. /****************************************************************
  344.  
  345.    gr_cls()
  346.  
  347. ****************************************************************/
  348.  
  349. gr_cls( screen )
  350.    int screen;
  351.    {
  352.    gr_rectangle( screen, 0, 0, mgr_grwind->xmax, mgr_grwind->ymax, 
  353.       BLACK, SOLID );
  354.    }
  355.  
  356.  
  357. /****************************************************************
  358.  
  359.    gr_pixel()
  360.  
  361. ****************************************************************/
  362.  
  363. gr_pixel( screen, x, y, color )
  364.    int screen;
  365.    int x, y;
  366.    int color;
  367.    {
  368.  
  369. #if    CHECK_PARAMS
  370.    if ( ( x < 0 ) || ( x > mgr_grwind->xmax ))
  371.       {
  372.       sprintf( bw_ebuf, "[pr:] gr_pixel(): x value is %d", x );
  373.       bw_error( bw_ebuf );
  374.       return BW_ERROR;
  375.       }
  376.    if ( ( y < 0 ) || ( y > mgr_grwind->ymax ))
  377.       {
  378.       sprintf( bw_ebuf, "[pr:] gr_pixel(): y value is %d", y );
  379.       bw_error( bw_ebuf );
  380.       return BW_ERROR;
  381.       }
  382. #endif
  383.  
  384.    mgr_color( color );
  385.    if ( screen == MGR_DRAWMAIN )
  386.       {
  387.        m_line( x, mgr_y( y ), x, mgr_y( y ) );
  388.       }
  389.    else
  390.       {
  391.       m_lineto( screen, x, mgr_y( y ), x, mgr_y( y ) );
  392.       }
  393.    }
  394.          
  395. /****************************************************************
  396.  
  397.    gr_line()
  398.  
  399. ****************************************************************/
  400.  
  401. gr_line( screen, x1, y1, x2, y2, color, style )
  402.    int screen;
  403.    int x1, y1, x2, y2;
  404.    int color, style;
  405.    {
  406.  
  407. #if    CHECKPARAMS
  408.    if ( ( x1 < 0 ) || ( x1 > mgr_grwind->xmax ))
  409.       {
  410.       sprintf( bw_ebuf, "[pr:] gr_line(): x1 value is %d", x1 );
  411.       bw_error( bw_ebuf );
  412.       return BW_ERROR;
  413.       }
  414.    if ( ( x2 < 0 ) || ( x2 > mgr_grwind->xmax ))
  415.       {
  416.       sprintf( bw_ebuf, "[pr:] gr_line(): x2 value is %d", x2 );
  417.       bw_error( bw_ebuf );
  418.       return BW_ERROR;
  419.       }
  420.    if ( ( y1 < 0 ) || ( y1 > mgr_grwind->ymax ))
  421.       {
  422.       sprintf( bw_ebuf, "[pr:] gr_line(): y1 value is %d", y1 );
  423.       bw_error( bw_ebuf );
  424.       return BW_ERROR;
  425.       }
  426.    if ( ( y2 < 0 ) || ( y2 > mgr_grwind->ymax ))
  427.       {
  428.       sprintf( bw_ebuf, "[pr:] gr_line(): y2 value is %d", y2 );
  429.       bw_error( bw_ebuf );
  430.       return BW_ERROR;
  431.       }
  432. #endif
  433.  
  434.    mgr_color( color );
  435.    if ( screen == MGR_DRAWMAIN )
  436.       {
  437.       m_line( x1, mgr_y( y1 ),
  438.          x2, mgr_y( y2 ) );
  439.       }
  440.    else
  441.       {
  442.       m_lineto( screen, x1, mgr_y( y1 ),
  443.          x2, mgr_y( y2 ) );
  444.       }
  445.    }
  446.  
  447. /****************************************************************
  448.  
  449.    gr_text()
  450.  
  451. ****************************************************************/
  452.  
  453. gr_text( screen, x, y, string, foreground, background )
  454.    int screen;
  455.    int x, y;
  456.    int foreground, background;
  457.    char *string;
  458.    {
  459.  
  460. #if    CHECK_PARAMS
  461.    if ( ( x < 0 ) || ( x > mgr_grwind->xmax ))
  462.       {
  463.       fprintf( stderr, "ERROR: [pr:] gr_text(): x value is %d", x );
  464.       kb_rx();
  465.       return BW_ERROR;
  466.       }
  467.    if ( ( y < 0 ) || ( y > mgr_grwind->ymax ))
  468.       {
  469.       fprintf( stderr, "ERROR: [pr:] gr_text(): y value is %d", y );
  470.       kb_rx();
  471.       return BW_ERROR;
  472.       }
  473. #endif
  474.  
  475.    m_func( B_SET );
  476. /*   m_move( 0, 0 ); */
  477.  
  478.    if ( foreground == WHITE )
  479.       {
  480.       m_clearmode( M_STANDOUT );
  481.       }
  482.    else
  483.       {
  484.       m_setmode( M_STANDOUT );
  485.       }
  486.    if ( screen == MGR_DRAWMAIN )
  487.       {
  488.       m_moveprint( x, mgr_y( y ), string );
  489.       }
  490.    else
  491.       {
  492.       m_stringto( screen, x, mgr_y( y ), string );
  493.       }
  494.    }
  495.  
  496. /****************************************************************
  497.  
  498.    gr_strlen()
  499.  
  500. ****************************************************************/
  501.  
  502. unsigned int
  503. gr_strlen( string )
  504.    char *string;
  505.    {
  506.    return ( strlen( string ) * mgr_grwind->fxsize );
  507.    }
  508.  
  509. /****************************************************************
  510.  
  511.    gr_rectangle()
  512.  
  513. ****************************************************************/
  514.  
  515. gr_rectangle( screen, x1, y1, x2, y2, color, style )
  516.    int screen;
  517.    int x1, y1, x2, y2;
  518.    int color, style;
  519.    {
  520.  
  521. #if    CHECK_PARAMS
  522.    if ( ( x1 < 0 ) || ( x1 > mgr_grwind->xmax ))
  523.       {
  524.       sprintf( bw_ebuf, "[pr:] gr_rectangle(): x1 value is %d", x1 );
  525.       bw_error( bw_ebuf );
  526.       return BW_ERROR;
  527.       }
  528.    if ( ( x2 < 0 ) || ( x2 > mgr_grwind->xmax ))
  529.       {
  530.       sprintf( bw_ebuf, "[pr:] gr_rectangle(): x2 value is %d", x2 );
  531.       bw_error( bw_ebuf );
  532.       return BW_ERROR;
  533.       }
  534.    if ( ( y1 < 0 ) || ( y1 > mgr_grwind->ymax ))
  535.       {
  536.       sprintf( bw_ebuf, "[pr:] gr_rectangle(): y1 value is %d", y1 );
  537.       bw_error( bw_ebuf );
  538.       return BW_ERROR;
  539.       }
  540.    if ( ( y2 < 0 ) || ( y2 > mgr_grwind->ymax ))
  541.       {
  542.       sprintf( bw_ebuf, "[pr:] gr_rectangle(): y2 value is %d", y2 );
  543.       bw_error( bw_ebuf );
  544.       return BW_ERROR;
  545.       }
  546. #endif
  547.  
  548.    switch( style )
  549.       {
  550.       case SOLID:
  551.          if ( color == WHITE )
  552.             {
  553.             m_func( B_SET );
  554.             }
  555.          else
  556.             {
  557.             m_func( B_CLEAR );
  558.             }
  559.          m_bitcopyto( x1, mgr_y( y2 ), 
  560.             abs( x2 - x1 ), abs( y2 - y1 ),
  561.             x1, mgr_y( y2 ),
  562.             screen, MGR_DRAWGRID ); 
  563.          break;
  564.       case GRID:
  565.       case HATCH:
  566.          m_func( B_SRC );
  567.          m_bitcopyto( x1, mgr_y( y2 ),
  568.             abs( x2 - x1 ), abs( y2 - y1 ),
  569.             x1, mgr_y( y2 ),
  570.             screen, MGR_DRAWGRID ); 
  571.          break;
  572.       case HOLLOW:
  573.       default:
  574.          mgr_color( color );
  575.          if ( screen == MGR_DRAWMAIN )
  576.             {
  577.             m_line( x1, mgr_y( y1 ), 
  578.                x2, mgr_y( y1 ) );
  579.             m_line( x2, mgr_y( y1 ), x2, 
  580.                mgr_y( y2 ) );
  581.             m_line( x1, mgr_y( y2 ), 
  582.                x2, mgr_y( y2 ) );
  583.             m_line( x1, mgr_y( y2 ), 
  584.                x1, mgr_y( y1 ) );
  585.             }
  586.          else
  587.             {
  588.             m_lineto( screen, x1, mgr_y( y1 ), 
  589.                x2, mgr_y( y1 ) );
  590.             m_lineto( screen, x2, mgr_y( y1 ), x2, 
  591.                mgr_y( y2 ) );
  592.             m_lineto( screen, x1, mgr_y( y2 ), 
  593.                x2, mgr_y( y2 ) );
  594.             m_lineto( screen, x1, mgr_y( y2 ), 
  595.                x1, mgr_y( y1 ) );
  596.             }
  597.          break;
  598.       }
  599.    }
  600.  
  601. /****************************************************************
  602.  
  603.    gr_circle()
  604.  
  605. ****************************************************************/
  606.  
  607. gr_circle( screen, x, y, radius, color, style )
  608.    int screen;
  609.    int x, y, radius;
  610.    int color, style;
  611.    {
  612.    register int c;
  613.  
  614. #if    CHECK_PARAMS
  615.    if ( ( x < 0 ) || ( x > mgr_grwind->xmax ))
  616.       {
  617.       sprintf( bw_ebuf, "[pr:] gr_circle(): x value is %d", x );
  618.       bw_error( bw_ebuf );
  619.       return BW_ERROR;
  620.       }
  621.    if ( ( y < 0 ) || ( y > mgr_grwind->ymax ))
  622.       {
  623.       sprintf( bw_ebuf, "[pr:] gr_circle(): y value is %d", y );
  624.       bw_error( bw_ebuf );
  625.       return BW_ERROR;
  626.       }
  627. #endif
  628.  
  629.    mgr_color( color );
  630.    switch( style )
  631.       {
  632.       case SOLID:
  633.       case HATCH:
  634.       case GRID:
  635.          for ( c = 0; c <= radius; ++c )
  636.             {
  637.             if ( screen == MGR_DRAWMAIN )
  638.                {
  639.                m_ellipse( x, mgr_y( y ), 
  640.                   c, ( c * gr_pxsize ) / gr_pysize );
  641.                }
  642.             else
  643.                {
  644.                m_ellipseto( screen, x, mgr_y( y ), 
  645.                   c, ( c * gr_pxsize ) / gr_pysize );
  646.                }
  647.             }
  648.          break;
  649.       case HOLLOW:
  650.       default:
  651.          if ( screen == MGR_DRAWMAIN )
  652.             {
  653.             m_ellipse( x, mgr_y( y ), 
  654.                radius, ( radius * gr_pxsize ) / gr_pysize );
  655.             }
  656.          else
  657.             {
  658.             m_ellipseto( screen, x, mgr_y( y ), 
  659.                radius, ( radius * gr_pxsize ) / gr_pysize );
  660.             }
  661.          break;
  662.       }
  663.    }
  664.  
  665. /****************************************************************
  666.  
  667.    gr_ellipse()
  668.  
  669. ****************************************************************/
  670.  
  671. gr_ellipse( screen, x, y, x_radius, y_radius, mode, color, style )
  672.    int screen;
  673.    int x, y, x_radius, y_radius;
  674.    int mode, color, style;
  675.    {
  676.    }
  677.          
  678. /****************************************************************
  679.  
  680.    gr_clip()
  681.  
  682. ****************************************************************/
  683.  
  684. gr_clip( screen, mode, x1, y1, x2, y2 )
  685.    int screen;
  686.    int mode;
  687.    int x1, y1, x2, y2;
  688.    {
  689.  
  690. #ifdef  DEBUG
  691.    if ( ( x1 < 0 ) || ( x1 > mgr_grwind->xmax ))
  692.       {
  693.       sprintf( bw_ebuf, "[pr:] gr_clip(): x1 value is %d", x1 );
  694.       bw_error( bw_ebuf );
  695.       return BW_ERROR;
  696.       }
  697.    if ( ( x2 < 0 ) || ( x2 > mgr_grwind->xmax ))
  698.       {
  699.       sprintf( bw_ebuf, "[pr:] gr_clip(): x2 value is %d", x2 );
  700.       bw_error( bw_ebuf );
  701.       return BW_ERROR;
  702.       }
  703.    if ( ( y1 < 0 ) || ( y1 > mgr_grwind->ymax ))
  704.       {
  705.       sprintf( bw_ebuf, "[pr:] gr_clip(): y1 value is %d", y1 );
  706.       bw_error( bw_ebuf );
  707.       return BW_ERROR;
  708.       }
  709.    if ( ( y2 < 0 ) || ( y2 > mgr_grwind->ymax ))
  710.       {
  711.       sprintf( bw_ebuf, "[pr:] gr_clip(): y2 value is %d", y2 );
  712.       bw_error( bw_ebuf );
  713.       return BW_ERROR;
  714.       }
  715. #endif
  716.  
  717.    return BW_ERROR;
  718.    }
  719.  
  720. /****************************************************************
  721.  
  722.    gr_font()
  723.  
  724. ****************************************************************/
  725.  
  726. gr_font( screen, type, rq_height )
  727.    int screen;
  728.    int type, rq_height;
  729.    {
  730.    static int x_fontno;
  731.  
  732.    if ( rq_height > 18 )
  733.       {
  734.       x_fontno = MGR_FONT4;
  735.       mgr_grwind->fysize = 20;
  736.       mgr_grwind->fxsize = 12;
  737.       }
  738.    else if ( rq_height > 15 )
  739.       {
  740.       x_fontno = MGR_FONT3;
  741.       mgr_grwind->fysize = 16;
  742.       mgr_grwind->fxsize = 8;
  743.       }
  744.    else if ( rq_height > 13 )
  745.       {
  746.       x_fontno = MGR_FONT2;
  747.       mgr_grwind->fysize = 14;
  748.       mgr_grwind->fxsize = 7;
  749.       }
  750. #ifdef    TINYFONT
  751.     else if ( rq_height > 9 )
  752.       {
  753.       x_fontno = MGR_FONT1;
  754.       mgr_grwind->fysize = 12;
  755.       mgr_grwind->fxsize = 6;
  756.       }
  757.    else 
  758.       {
  759.       x_fontno = MGR_FONT0;
  760.       mgr_grwind->fysize = 7;
  761.       mgr_grwind->fxsize = 4;
  762.       }
  763. #else
  764.    else
  765.       {
  766.       x_fontno = MGR_FONT1;
  767.       mgr_grwind->fysize = 12;
  768.       mgr_grwind->fxsize = 6;
  769.       }
  770. #endif      
  771.  
  772.    mgr_curspark();            /* get cursor out of the way */
  773.    m_font( x_fontno );
  774.  
  775.    }
  776.  
  777. /****************************************************************
  778.  
  779.    gr_blit()
  780.  
  781. ****************************************************************/
  782.  
  783. gr_blit( src, dst, x1, y1, x2, y2 )
  784.    int src, dst;
  785.    int x1, y1, x2, y2;
  786.    {
  787.  
  788. #if    CHECK_PARAMS
  789.    if ( ( x1 < 0 ) || ( x1 > mgr_grwind->xmax ))
  790.       {
  791.       sprintf( bw_ebuf, "[pr:] gr_blit(): x1 value is %d", x1 );
  792.       bw_error( bw_ebuf );
  793.       return BW_ERROR;
  794.       }
  795.    if ( ( x2 < 0 ) || ( x2 > mgr_grwind->xmax ))
  796.       {
  797.       sprintf( bw_ebuf, "[pr:] gr_blit(): x2 value is %d", x2 );
  798.       bw_error( bw_ebuf );
  799.       return BW_ERROR;
  800.       }
  801.    if ( ( y1 < 0 ) || ( y1 > mgr_grwind->ymax ))
  802.       {
  803.       sprintf( bw_ebuf, "[pr:] gr_blit(): y1 value is %d", y1 );
  804.       bw_error( bw_ebuf );
  805.       return BW_ERROR;
  806.       }
  807.    if ( ( y2 < 0 ) || ( y2 > mgr_grwind->ymax ))
  808.       {
  809.       sprintf( bw_ebuf, "[pr:] gr_blit(): y2 value is %d", y2 );
  810.       bw_error( bw_ebuf );
  811.       return BW_ERROR;
  812.       }
  813.    if ( src == dst )
  814.       {
  815.       sprintf( bw_ebuf, "[pr:] gr_blit(): src == dst" );
  816.       bw_error( bw_ebuf );
  817.       return BW_ERROR;
  818.       }
  819. #endif
  820.  
  821.    if ( src == dst )
  822.       {
  823.       return BW_ERROR;
  824.       }
  825.  
  826.    m_func( B_SRC );
  827.    m_bitcopyto( x1, mgr_y( y2 ), x2 - x1, y2 - y1, 
  828.       x1, mgr_y( y2 ), dst, src );
  829.    }
  830.  
  831. /****************************************************************
  832.  
  833.    gr_imsave()
  834.  
  835. ****************************************************************/
  836.  
  837. gr_imsave( screen, mode, x1, y1, x2, y2, image )
  838.    int screen; 
  839.    int mode, x1, y1, x2, y2;
  840.    int *image;
  841.    {
  842.  
  843. #if    CHECK_PARAMS
  844.    if ( ( x1 < 0 ) || ( x1 > mgr_grwind->xmax ))
  845.       {
  846.       sprintf( bw_ebuf, "[pr:] gr_save(): x1 value is %d", x1 );
  847.       bw_error( bw_ebuf );
  848.       return BW_ERROR;
  849.       }
  850.    if ( ( x2 < 0 ) || ( x2 > mgr_grwind->xmax ))
  851.       {
  852.       sprintf( bw_ebuf, "[pr:] gr_save(): x2 value is %d", x2 );
  853.       bw_error( bw_ebuf );
  854.       return BW_ERROR;
  855.       }
  856.    if ( ( y1 < 0 ) || ( y1 > mgr_grwind->ymax ))
  857.       {
  858.       sprintf( bw_ebuf, "[pr:] gr_save(): y1 value is %d", y1 );
  859.       bw_error( bw_ebuf );
  860.       return BW_ERROR;
  861.       }
  862.    if ( ( y2 < 0 ) || ( y2 > mgr_grwind->ymax ))
  863.       {
  864.       sprintf( bw_ebuf, "[pr:] gr_save(): y2 value is %d", y2 );
  865.       bw_error( bw_ebuf );
  866.       return BW_ERROR;
  867.       }
  868. #endif
  869.  
  870.    if ( mode == TRUE )
  871.       {
  872.       *image = mgr_getbno();                /* assign a number */
  873.  
  874. #ifdef OLD_DEBUG
  875.       fprintf( stderr, "\nDEBUG: Window number is %d", *i );
  876.       kb_rx();
  877. #endif
  878.  
  879.       m_bitcreate( *image, abs( x2 - x1 ), abs( y2 - y1 ) );
  880.  
  881.       m_func( B_SRC );
  882.       m_bitcopyto( x1, mgr_y( y2 ), 
  883.          abs( x2 - x1 ), abs( y2 - y1 ),
  884.      x1, mgr_y( y2 ), *image, MGR_DRAWMAIN );
  885.       }
  886.    else
  887.       {
  888. #ifdef OLD_DEBUG
  889.       fprintf( stderr, "\nDEBUG: Window number is %d", *image );
  890.       kb_rx();
  891. #endif
  892.       m_func( B_SRC );
  893.       m_bitcopyto( x1, mgr_y( y2 ),
  894.          abs( x2 - x1 ), abs( y2 - y1 ),
  895.      x1, mgr_y( y2 ), MGR_DRAWMAIN, *image );
  896.       }
  897.    }
  898.  
  899. /****************************************************************
  900.  
  901.     gr_imfree()
  902.  
  903. ****************************************************************/
  904.  
  905. gr_imfree( image )
  906.    int image;
  907.    {
  908.    m_bitdestroy( image );
  909.    }
  910.  
  911. /****************************************************************
  912.  
  913.    gr_mouse()
  914.  
  915. ****************************************************************/
  916.  
  917. gr_mouse( mode, x, y, buttons )
  918.    int mode;
  919.    int *x, *y;
  920.    int *buttons;
  921.    {
  922.    static int m_pending = FALSE, x_save, y_save;
  923.    static int m_prevr;
  924.    int c, r;
  925.  
  926.    switch( mode )
  927.       {
  928.       case SAMPLE:
  929.          if ( m_pending == TRUE )
  930.             {
  931.             *x = x_save;
  932.             *y = y_save;
  933.             return TRUE;
  934.             }
  935.          r = mgr_mouse( x, y );
  936.          *y = mgr_y( *y );
  937.          if ( r == TRUE )
  938.             {
  939.             m_pending = TRUE;
  940.             x_save = *x;
  941.             y_save = *y;
  942.             }
  943.          return r;
  944.          break;
  945.       case WAIT:
  946.          if ( m_pending == TRUE )
  947.             {
  948.             m_pending = FALSE;
  949.             *x = x_save;
  950.             *y = y_save;
  951.             return TRUE;
  952.             }
  953.          c = FALSE;
  954.          while( c == FALSE )
  955.             {
  956.             c = r = mgr_mouse( x, y );
  957.             *y = mgr_y( *y );
  958.             }
  959.          m_pending = FALSE;
  960.          m_prevr = r;
  961.          return TRUE;
  962.          break;
  963.       default:
  964. #ifdef    DEBUG
  965.          sprintf( bw_ebuf, "gr_mouse() received mode %d", mode );
  966.          bw_error( bw_ebuf );
  967. #endif
  968.          return BW_ERROR;
  969.          break;
  970.       }
  971.    
  972.    }
  973.  
  974. mgr_mouse( x, y )
  975.    int *x, *y;
  976.    {
  977.    static int r = 0, x_prevr = 0;
  978.  
  979.    r = get_mouse( x, y );
  980. #ifdef    OLD_DEBUG
  981.    sprintf( bw_ebuf, "r = %d", r );
  982.    gr_text( GR_PRIMARY, 12, 12, bw_ebuf, WHITE, BLACK );
  983. #endif
  984.    if ( r == x_prevr )
  985.       {
  986.       return FALSE;
  987.       }
  988.    x_prevr = r;
  989.    return TRUE;
  990.    }
  991.  
  992. mgr_y( oldyval )
  993.    int oldyval;
  994.    {
  995.    return (( mgr_grwind->ymax  ) - oldyval );
  996.    }
  997.  
  998. mgr_color( color )
  999.    int color;
  1000.    {
  1001.    if ( color == WHITE )
  1002.       {
  1003.       m_func( B_SET );
  1004.       }
  1005.    else
  1006.       {
  1007.       m_func( B_CLEAR );
  1008.       }
  1009.    }
  1010.  
  1011. mgr_getbno()
  1012.    {
  1013.    static int x = MGR_DRAWSTART;
  1014.  
  1015.    ++x;
  1016.    return x;
  1017.    }
  1018.  
  1019. mgr_curspark()
  1020.    {
  1021.    m_movecursor( 0, 85 );
  1022.    }
  1023.  
  1024.